"""
回调和事件管理模块
================

该模块负责处理读取和写入操作前后的回调和事件。
"""


from typing import Any, Dict, List, Callable, Optional, Union
from .typedef import AddressType, PreReaderType, PostReaderType
from ..utils.logger import get_logger,default_logger


class CallbackManager:
    """回调管理器"""

    def __init__(self):
        """
        初始化回调管理器
        """
        self.logger = default_logger.getChild("CallbackManager")

        # 读取回调
        self._pre_read_callbacks: List[Callable] = []
        self._post_read_callbacks: List[Callable] = []

        # 写入回调
        self._pre_write_callbacks: List[Callable] = []
        self._post_write_callbacks: List[Callable] = []

    def add_pre_read_callback(self, callback: Callable) -> None:
        """
        添加读取前回调函数

        Args:
            callback: 回调函数
        """
        self.logger.debug(f"添加读取前回调函数: {callback}")

        if callable(callback):
            self._pre_read_callbacks.append(callback)
            self.logger.debug(f"成功添加读取前回调函数")
        else:
            self.logger.warning("尝试添加不可调用的读取前回调函数")

    def add_post_read_callback(self, callback: Callable) -> None:
        """
        添加读取后回调函数

        Args:
            callback: 回调函数
        """
        self.logger.debug(f"添加读取后回调函数: {callback}")

        if callable(callback):
            self._post_read_callbacks.append(callback)
            self.logger.debug(f"成功添加读取后回调函数")
        else:
            self.logger.warning("尝试添加不可调用的读取后回调函数")

    def remove_pre_read_callback(self, callback: Callable) -> None:
        """
        移除读取前回调函数

        Args:
            callback: 回调函数
        """
        self.logger.debug(f"移除读取前回调函数: {callback}")

        if callback in self._pre_read_callbacks:
            self._pre_read_callbacks.remove(callback)
            self.logger.debug(f"成功移除读取前回调函数")
        else:
            self.logger.warning("尝试移除不存在的读取前回调函数")

    def remove_post_read_callback(self, callback: Callable) -> None:
        """
        移除读取后回调函数

        Args:
            callback: 回调函数
        """
        self.logger.debug(f"移除读取后回调函数: {callback}")

        if callback in self._post_read_callbacks:
            self._post_read_callbacks.remove(callback)
            self.logger.debug(f"成功移除读取后回调函数")
        else:
            self.logger.warning("尝试移除不存在的读取后回调函数")

    def add_pre_write_callback(self, callback: Callable) -> None:
        """
        添加写入前回调函数

        Args:
            callback: 回调函数
        """
        self.logger.debug(f"添加写入前回调函数: {callback}")

        if callable(callback):
            self._pre_write_callbacks.append(callback)
            self.logger.debug(f"成功添加写入前回调函数")
        else:
            self.logger.warning("尝试添加不可调用的写入前回调函数")

    def add_post_write_callback(self, callback: Callable) -> None:
        """
        添加写入后回调函数

        Args:
            callback: 回调函数
        """
        self.logger.debug(f"添加写入后回调函数: {callback}")

        if callable(callback):
            self._post_write_callbacks.append(callback)
            self.logger.debug(f"成功添加写入后回调函数")
        else:
            self.logger.warning("尝试添加不可调用的写入后回调函数")

    def remove_pre_write_callback(self, callback: Callable) -> None:
        """
        移除写入前回调函数

        Args:
            callback: 回调函数
        """
        self.logger.debug(f"移除写入前回调函数: {callback}")

        if callback in self._pre_write_callbacks:
            self._pre_write_callbacks.remove(callback)
            self.logger.debug(f"成功移除写入前回调函数")
        else:
            self.logger.warning("尝试移除不存在的写入前回调函数")

    def remove_post_write_callback(self, callback: Callable) -> None:
        """
        移除写入后回调函数

        Args:
            callback: 回调函数
        """
        self.logger.debug(f"移除写入后回调函数: {callback}")

        if callback in self._post_write_callbacks:
            self._post_write_callbacks.remove(callback)
            self.logger.debug(f"成功移除写入后回调函数")
        else:
            self.logger.warning("尝试移除不存在的写入后回调函数")

    def notify_read_start(self, address_info: Dict[str, Any], config: Dict[str, Any]) -> None:
        """
        通知读取开始

        Args:
            address_info: 地址信息
            config: 配置信息
        """
        self.logger.info("读取操作开始")
        self.logger.debug(f"地址信息: {address_info}")
        self.logger.debug(f"配置信息: {config}")

        try:
            # 执行预读取处理器
            prereaders = config.get('prereaders', [])
            for prereader in prereaders:
                if callable(prereader):
                    # 这里可以传递地址信息给预处理器
                    try:
                        prereader(address_info)
                        self.logger.debug(f"执行预读取处理器: {prereader}")
                    except Exception as e:
                        self.logger.error(f"执行预读取处理器 {prereader} 时发生错误: {e}")
                        # 忽略预处理器中的异常

            # 执行回调函数
            for callback in self._pre_read_callbacks:
                try:
                    callback(address_info, config)
                    self.logger.debug(f"执行读取前回调函数: {callback}")
                except Exception as e:
                    self.logger.error(f"执行读取前回调函数 {callback} 时发生错误: {e}")
                    # 忽略回调函数中的异常
        except Exception as e:
            self.logger.error(f"处理读取开始通知时发生错误: {e}")

    def notify_read_complete(self, results: Dict[str, Any], config: Dict[str, Any]) -> None:
        """
        通知读取完成

        Args:
            results: 读取结果
            config: 配置信息
        """
        self.logger.info("读取操作完成")
        self.logger.debug(f"读取结果: {results}")
        self.logger.debug(f"配置信息: {config}")

        try:
            # 执行回调函数
            for callback in self._post_read_callbacks:
                try:
                    callback(results, config)
                    self.logger.debug(f"执行读取后回调函数: {callback}")
                except Exception as e:
                    self.logger.error(f"执行读取后回调函数 {callback} 时发生错误: {e}")
                    # 忽略回调函数中的异常
        except Exception as e:
            self.logger.error(f"处理读取完成通知时发生错误: {e}")

    def notify_write_start(self, address_info: Dict[str, Any], config: Dict[str, Any]) -> None:
        """
        通知写入开始

        Args:
            address_info: 地址信息
            config: 配置信息
        """
        self.logger.info("写入操作开始")
        self.logger.debug(f"地址信息: {address_info}")
        self.logger.debug(f"配置信息: {config}")

        try:
            # 执行预处理器
            preprocessors = config.get('preprocessors', [])
            for preprocessor in preprocessors:
                if callable(preprocessor):
                    try:
                        # 这里可以传递地址信息给预处理器
                        preprocessor(address_info)
                        self.logger.debug(f"执行预处理器: {preprocessor}")
                    except Exception as e:
                        self.logger.error(f"执行预处理器 {preprocessor} 时发生错误: {e}")
                        # 发生异常时继续执行下一个预处理器

            # 执行回调函数
            for callback in self._pre_write_callbacks:
                try:
                    callback(address_info, config)
                    self.logger.debug(f"执行写入前回调函数: {callback}")
                except Exception as e:
                    self.logger.error(f"执行写入前回调函数 {callback} 时发生错误: {e}")
                    # 忽略回调函数中的异常
        except Exception as e:
            self.logger.error(f"处理写入开始通知时发生错误: {e}")

    def notify_write_complete(self, result: Any, config: Dict[str, Any]) -> None:
        """
        通知写入完成

        Args:
            result: 写入结果
            config: 配置信息
        """
        self.logger.info("写入操作完成")
        self.logger.debug(f"写入结果: {result}")
        self.logger.debug(f"配置信息: {config}")

        try:
            # 执行后处理器
            postprocessors = config.get('postprocessors', [])
            for postprocessor in postprocessors:
                if callable(postprocessor):
                    try:
                        postprocessor(result)
                        self.logger.debug(f"执行后处理器: {postprocessor}")
                    except Exception as e:
                        self.logger.error(f"执行后处理器 {postprocessor} 时发生错误: {e}")
                        # 发生异常时继续执行下一个后处理器

            # 执行回调函数
            for callback in self._post_write_callbacks:
                try:
                    callback(result, config)
                    self.logger.debug(f"执行写入后回调函数: {callback}")
                except Exception as e:
                    self.logger.error(f"执行写入后回调函数 {callback} 时发生错误: {e}")
                    # 忽略回调函数中的异常
        except Exception as e:
            self.logger.error(f"处理写入完成通知时发生错误: {e}")

    def log_operation(self, operation: str, details: Dict[str, Any]) -> None:
        """
        记录操作日志

        Args:
            operation: 操作类型
            details: 操作详情
        """
        self.logger.info(f"操作: {operation}")
        self.logger.debug(f"操作详情: {details}")